package com.elitel.frame.core.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.RandomAccessFile;
import java.io.Reader;

public class FileControlUtil {

    // 文件复制
    public static boolean copyFile(String source, String copy) throws Exception {
        source = source.replace("\\", "/");
        copy = copy.replace("\\", "/");

        File source_file = new File(source);
        File copy_file = new File(copy);

        // BufferedStream缓冲字节流

        if (!source_file.exists()) {
            throw new IOException("文件复制失败：源文件（" + source_file + "） 不存在");
        }
        if (copy_file.isDirectory()) {
            throw new IOException("文件复制失败：复制路径（" + copy_file + "） 错误");
        }
        File parent = copy_file.getParentFile();
        // 创建复制路径
        if (!parent.exists()) {
            parent.mkdirs();
        }
        // 创建复制文件
        if (!copy_file.exists()) {
            copy_file.createNewFile();
        }

        FileInputStream fis = new FileInputStream(source_file);
        FileOutputStream fos = new FileOutputStream(copy_file);

        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        byte[] KB = new byte[1024];
        int index;
        while ((index = bis.read(KB)) != -1) {
            bos.write(KB, 0, index);
        }

        bos.close();
        bis.close();
        fos.close();
        fis.close();

        if (!copy_file.exists()) {
            return false;
        } else if (source_file.length() != copy_file.length()) {
            return false;
        } else {
            return true;
        }

    }

    // 文件重命名
    public static boolean renameFile(String url, String new_name) throws Exception {
        String old_url = url;
        old_url = old_url.replace("\\", "/");
        File old_file = new File(old_url);
        if (!old_file.exists()) {
            throw new IOException("文件重命名失败，文件（"+old_file+"）不存在");
        }
        System.out.println(old_file.exists());

        String old_name = old_file.getName();
        // 获得父路径
        String parent = old_file.getParent();
        // 重命名
        String new_url = parent + "/" + new_name;
        File new_file = new File(new_url);
        old_file.renameTo(new_file);

        System.out.println("原文件：" + old_file.getName());
        System.out.println("新文件：" + new_file.getName());
        new_name = new_file.getName();
        old_name = old_file.getName();
        if (new_name.equals(old_name)) {
            return false;
        } else {
            return true;
        }

    }

    // 文件删除
    public static boolean deleteFile(String url) throws Exception {
        url = url.replace("\\", "/");
        File file = new File(url);

        if (file.isFile()) {
            if (file.exists()) {
                file.delete();
            }
        }else{
            throw new IOException("文件删除失败：（"+file+"）错误");
        }
        if (file.exists()) {
            return false;
        } else {
            return true;
        }
    }

    // 创建文件夹
    public static boolean createPath(String url) throws Exception {
        url = url.replace("\\", "/");
        File folder = new File(url);
        if(!folder.isDirectory()){
            throw new IOException("创建文件夹失败：（"+folder+"）不是文件夹路径");
        }

        if (!folder.isFile()) {
            if (!folder.exists()) {
                folder.mkdirs();
            }
        }
        // 检测是否创建成功
        if (folder.isDirectory() && folder.exists()) {
            return true;
        } else {
            return false;
        }

    }
    
    /**
	 * <pre>copyFolder(递归复制文件夹包含所有文件)   
	 * @author：FanWenquan    
	 * @date：2017年11月2日 下午12:00:10   
	 * @param oldPath
	 * @param newPath
	 * @throws Exception</pre>
	 */
	public static void copyFolder(String oldPath, String newPath) throws Exception{
		 //需要被复制文件夹的位置
        String url1 = oldPath;
        //最后被复制的文件夹
        String url2 = newPath;
        //将这2个文件夹包装成File对象
        File file1 = new File(url1);
        File file2 = new File(url2);
        //创建目标文件夹
        if (!file2.exists()) {
        	 file2.mkdirs();
        }
        //对源文件夹进行遍历
        File[] files = file1.listFiles();
        for (int a = 0; a < files.length; a++) {
            //是标准文件,我们就直接进行复制动作
            if (files[a].isFile()) {
                //确认目标文件的需要被复制到的位置,它肯定是在目标文件夹下面
                File target = new File(file2, files[a].getName());
                copyFile(files[a], target);
            }
            if(files[a].isDirectory()){
                //文件夹下面还是个文件夹,这个时候去拿到文件夹的路径
                String source1 = url1+File.separator+files[a].getName();
                String target1 = url2+File.separator+files[a].getName();
                copyDir(source1,target1);
            }
        }
	}
	
	 private static void copyDir(String source1, String target1) throws IOException {
	         File source = new File(source1);
	         File target = new File(target1);
	         target.mkdirs();
	         File[] files = source.listFiles();
	         for(int a=0;a<files.length;a++){
	             if(files[a].isFile()){
	                 File target2 = new File(target,files[a].getName());
	                 copyFile(files[a], target2);
	             }
	             if(files[a].isDirectory()){
	                 String source3 = source1 +File.separator + files[a].getName();
	                 String target3 = target1 +File.separator + files[a].getName();
	                 //递归,对还是文件夹的文件夹在调用copyDir的方法,上面的if条件是递归的出口
	                 copyDir(source3,target3);
	             }
	         }
	 }

	 private static void copyFile(File file, File target)
	         throws IOException {
	     BufferedInputStream bis = new BufferedInputStream(
	             new FileInputStream(file));
	     BufferedOutputStream bos = new BufferedOutputStream(
	             new FileOutputStream(target));
	     byte[] buf = new byte[1024];
	     int len = 0;
	     while((len=bis.read(buf))!= -1){
	         bos.write(buf, 0,len);
	     }
	     bis.close();
	     bos.close();
	 }
	 
	 /**  
	     * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。  
	    */  
	    public static void readFileByBytes(String fileName) {  
	        File file = new File(fileName);  
	        InputStream in = null;  
	        try {  
	            System.out.println("以字节为单位读取文件内容，一次读一个字节：");  
	            // 一次读一个字节  
	            in = new FileInputStream(file);  
	            int tempbyte;  
	            while ((tempbyte = in.read()) != -1) {  
	                System.out.write(tempbyte);                  
	            }  
	            System.out.println();  
	            in.close();  
	        } catch (IOException e) {  
	            e.printStackTrace();  
	            return;  
	        }  
	        try {  
	            System.out.println("以字节为单位读取文件内容，一次读多个字节：");  
	            // 一次读多个字节  
	            byte[] tempbytes = new byte[256];  
	            int byteread = 0;  
	            in = new FileInputStream(fileName);  
	            FileControlUtil.showAvailableBytes(in);  
	            // 读入多个字节到字节数组中，byteread为一次读入的字节数  
	            while ((byteread = in.read(tempbytes)) != -1) {  
	                System.out.write(tempbytes, 0, byteread);  
	            }  
	            System.out.println();  
	        } catch (Exception e1) {  
	            e1.printStackTrace();  
	        } finally {  
	            if (in != null) {  
	                try {  
	                    in.close();  
	                } catch (IOException e1) {  
	                }  
	            }  
	        }  
	    }  
	  
	    /**  
	     * 以字符为单位读取文件，常用于读文本，数字等类型的文件  
	    */  
	    public static void readFileByChars(String fileName) {  
	        File file = new File(fileName);  
	        Reader reader = null;  
	        try {  
	            System.out.println("以字符为单位读取文件内容，一次读一个字符：");  
	            // 一次读一个字符  
	            reader = new InputStreamReader(new FileInputStream(file));  
	            int tempchar;  
	            while ((tempchar = reader.read()) != -1) {  
	               // 对于windows下，\r\n这两个字符在一起时，表示一个换行。  
	               // 但如果这两个字符分开显示时，会换两次行。  
	               // 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。  
	               if (((char) tempchar) != '\r') {  
	                    System.out.print((char) tempchar);                   
	               }  
	            }  
	            System.out.println();  
	            reader.close();  
	        } catch (Exception e) {  
	            e.printStackTrace();  
	        }  
	        try {  
	            System.out.println("以字符为单位读取文件内容，一次读多个字符：");  
	            // 一次读多个字符  
	            char[] tempchars = new char[32];  
	             
	            int charread = 0;  
	            reader = new InputStreamReader(new FileInputStream(fileName));  
	            // 读入多个字符到字符数组中，charread为一次读取字符数  
	            while ((charread = reader.read(tempchars)) != -1) {  
	                // 同样屏蔽掉\r不显示  
	                if ((charread == tempchars.length) && (tempchars[tempchars.length - 1] != '\r')){  
	                    System.out.print(tempchars);  
	                }else{  
	                    for(int i = 0; i < charread; i++){  
	                        if (tempchars[i] == '\r') {  
	                            continue;  
	                        } else {  
	                            System.out.print(tempchars[i]);  
	                        }  
	                    }  
	                }  
	            }  
	            System.out.println();  
	        } catch (Exception e1) {  
	            e1.printStackTrace();  
	        } finally {  
	            if (reader != null) {  
	                try {  
	                    reader.close();  
	                } catch (IOException e1) {  
	                }  
	            }  
	        }  
	    }  
	  
	    /**  
	     * 以行为单位读取文件，常用于读面向行的格式化文件  
	    */  
	    public static void readFileByLines(String fileName) {  
	        File file = new File(fileName);  
	        BufferedReader reader = null;  
	        try {  
	            System.out.println("以行为单位读取文件内容，一次读一整行：");  
	            reader = new BufferedReader(new FileReader(file));  
	            String tempString = null;  
	            int line = 1;  
	            // 一次读入一行，直到读入null为文件结束  
	            while ((tempString = reader.readLine()) != null) {  
	                // 显示行号  
	               System.out.println("line " + line + ": " + tempString);  
	               line++;  
	            }  
	            System.out.println();  
	            reader.close();  
	        } catch (IOException e) {  
	            e.printStackTrace();  
	        } finally {  
	            if (reader != null) {  
	                try {  
	                    reader.close();  
	                } catch (IOException e1) {  
	                }  
	            }  
	        }  
	    }  
	  
	    /**  
	     * 随机读取文件内容  
	    */  
	    public static void readFileByRandomAccess(String fileName) {  
	        RandomAccessFile randomFile = null;  
	        try {  
	           System.out.println("随机读取一段文件内容：");  
	           // 打开一个随机访问文件流，按只读方式  
	           randomFile = new RandomAccessFile(fileName, "r");  
	           // 文件长度，字节数  
	           long fileLength = randomFile.length();  
	           // 读文件的起始位置  
	           int beginIndex = (fileLength > 6) ? 6 : 0;  
	           // 将读文件的开始位置移到beginIndex位置。  
	           randomFile.seek(beginIndex);  
	           byte[] bytes = new byte[10];  
	           int byteread = 0;  
	           // 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。  
	           // 将一次读取的字节数赋给byteread  
	           while ((byteread = randomFile.read(bytes)) != -1){  
	                System.out.write(bytes, 0, byteread);  
	           }  
	           System.out.println();  
	        } catch (IOException e) {  
	           e.printStackTrace();  
	        } finally {  
	            if (randomFile != null) {  
	                try {  
	                    randomFile.close();  
	                } catch (IOException e1) {  
	                }  
	            }  
	        }  
	    }  
	  
	    /**  
	     * 显示输入流中还剩的字节数  
	    */  
	    private static void showAvailableBytes(InputStream in) {  
	        try {  
	            System.out.println("当前字节输入流中的字节数为:" + in.available());  
	        } catch (IOException e) {  
	            e.printStackTrace();  
	        }  
	    }  
	    
	    /**  
	     * A方法追加文件：使用RandomAccessFile  
	     */  
	    public static void appendMethodA(String fileName, String content) {  
	        try {
	        	File file = new File(fileName);
	        	if (!file.exists()) {
	        		file.createNewFile();
	            }
	            // 打开一个随机访问文件流，按读写方式  
	            RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");  
	            // 文件长度，字节数  
	            long fileLength = randomFile.length();  
	            //将写文件指针移到文件尾。  
	            randomFile.seek(fileLength);  
	            randomFile.writeBytes(content);  
	            randomFile.close();  
	        } catch (IOException e) {  
	            e.printStackTrace();  
	        }  
	    }  
	  
	    /**  
	     * B方法追加文件：使用FileWriter  
	     */  
	    public static void appendMethodB(String fileName, String content) {  
	        try {
	        	File file = new File(fileName);
	        	if (!file.exists()) {
	        		file.createNewFile();
	            }
	            //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件  
	        	FileOutputStream fos = new FileOutputStream(fileName, true);
	            OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");
	            osw.write(content + "\r\n");
	            osw.flush();
	            osw.close();
	        } catch (IOException e) {  
	            e.printStackTrace();  
	        }  
	    }
	    
	    /**
	     * 递归删除目录下的所有文件及子目录下所有文件
	     */
		public static boolean deleteDir(File dir) {
	        if (dir.isDirectory()) {
	            String[] children = dir.list();
	            for (int i=0; i<children.length; i++) {
	                boolean success = deleteDir(new File(dir, children[i]));
	                if (!success) {
	                    return false;
	                }
	            }
	        }
	        // 目录此时为空，可以删除
	        return dir.delete();
	    }
}

